home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / umich / tex / texsrc.arc / TEX2.C < prev    next >
C/C++ Source or Header  |  1988-09-14  |  46KB  |  2,010 lines
  1. overlay "tex2"
  2. #define EXTERN extern
  3. #include "texd.h"
  4.  
  5.  
  6. #ifdef STAT
  7. zshoweqtb ( n ) 
  8. halfword n ; 
  9. {r_showeqtb 
  10.   if ( n < 1 ) 
  11.   printchar ( 63 ) ; 
  12.   else if ( n < 3526 ) 
  13.   {
  14.     sprintcs ( n ) ; 
  15.     printchar ( 61 ) ; 
  16.     printcmdchr ( eqtb [ n ] .hh.b0 , eqtb [ n ] .hh .v.RH ) ; 
  17.     if ( eqtb [ n ] .hh.b0 >= 110 ) 
  18.     {
  19.       printchar ( 58 ) ; 
  20.       showtokenlis ( mem [(long) eqtb [ n ] .hh .v.RH ] .hh .v.RH , 0 , 32 ) ; 
  21.     } 
  22.   } 
  23.   else if ( n < 4056 ) 
  24.   if ( n < 3544 ) 
  25.   {
  26.     printskippar ( n - 3526 ) ; 
  27.     printchar ( 61 ) ; 
  28.     if ( n < 3541 ) 
  29.     printspec ( eqtb [ n ] .hh .v.RH , 262 ) ; 
  30.     else printspec ( eqtb [ n ] .hh .v.RH , 205 ) ; 
  31.   } 
  32.   else if ( n < 3800 ) 
  33.   {
  34.     printesc ( 260 ) ; 
  35.     printint ( n - 3544 ) ; 
  36.     printchar ( 61 ) ; 
  37.     printspec ( eqtb [ n ] .hh .v.RH , 262 ) ; 
  38.   } 
  39.   else { 
  40.     printesc ( 261 ) ; 
  41.     printint ( n - 3800 ) ; 
  42.     printchar ( 61 ) ; 
  43.     printspec ( eqtb [ n ] .hh .v.RH , 205 ) ; 
  44.   } 
  45.   else if ( n < 5267 ) 
  46.   if ( n == 4056 ) 
  47.   {
  48.     printesc ( 273 ) ; 
  49.     printchar ( 61 ) ; 
  50.     if ( eqtb [ 4056 ] .hh .v.RH == 0 ) 
  51.     printchar ( 48 ) ; 
  52.     else printint ( mem [(long) eqtb [ 4056 ] .hh .v.RH ] .hh .v.LH ) ; 
  53.   } 
  54.   else if ( n < 4066 ) 
  55.   {
  56.     printcmdchr ( 71 , n ) ; 
  57.     printchar ( 61 ) ; 
  58.     if ( eqtb [ n ] .hh .v.RH != 0 ) 
  59.     showtokenlis ( mem [(long) eqtb [ n ] .hh .v.RH ] .hh .v.RH , 0 , 32 ) ; 
  60.   } 
  61.   else if ( n < 4322 ) 
  62.   {
  63.     printesc ( 272 ) ; 
  64.     printint ( n - 4066 ) ; 
  65.     printchar ( 61 ) ; 
  66.     if ( eqtb [ n ] .hh .v.RH != 0 ) 
  67.     showtokenlis ( mem [(long) eqtb [ n ] .hh .v.RH ] .hh .v.RH , 0 , 32 ) ; 
  68.   } 
  69.   else if ( n < 4578 ) 
  70.   {
  71.     printesc ( 274 ) ; 
  72.     printint ( n - 4322 ) ; 
  73.     printchar ( 61 ) ; 
  74.     if ( eqtb [ n ] .hh .v.RH == 0 ) 
  75.     print ( 275 ) ; 
  76.     else { 
  77.       depththresho = 0 ; 
  78.       breadthmax = 1 ; 
  79.       shownodelist ( eqtb [ n ] .hh .v.RH ) ; 
  80.     } 
  81.   } 
  82.   else if ( n < 4627 ) 
  83.   {
  84.     if ( n == 4578 ) 
  85.     print ( 276 ) ; 
  86.     else if ( n < 4595 ) 
  87.     {
  88.       printesc ( 277 ) ; 
  89.       printint ( n - 4579 ) ; 
  90.     } 
  91.     else if ( n < 4611 ) 
  92.     {
  93.       printesc ( 278 ) ; 
  94.       printint ( n - 4595 ) ; 
  95.     } 
  96.     else { 
  97.       printesc ( 279 ) ; 
  98.       printint ( n - 4611 ) ; 
  99.     } 
  100.     printchar ( 61 ) ; 
  101.     printesc ( hash [ 3268 + eqtb [ n ] .hh .v.RH ] .v.RH ) ; 
  102.   } 
  103.   else if ( n < 5139 ) 
  104.   {
  105.     if ( n < 4755 ) 
  106.     {
  107.       printesc ( 280 ) ; 
  108.       printint ( n - 4627 ) ; 
  109.     } 
  110.     else if ( n < 4883 ) 
  111.     {
  112.       printesc ( 281 ) ; 
  113.       printint ( n - 4755 ) ; 
  114.     } 
  115.     else if ( n < 5011 ) 
  116.     {
  117.       printesc ( 282 ) ; 
  118.       printint ( n - 4883 ) ; 
  119.     } 
  120.     else { 
  121.       printesc ( 283 ) ; 
  122.       printint ( n - 5011 ) ; 
  123.     } 
  124.     printchar ( 61 ) ; 
  125.     printint ( eqtb [ n ] .hh .v.RH ) ; 
  126.   } 
  127.   else { 
  128.     printesc ( 284 ) ; 
  129.     printint ( n - 5139 ) ; 
  130.     printchar ( 61 ) ; 
  131.     printint ( eqtb [ n ] .hh .v.RH ) ; 
  132.   } 
  133.   else if ( n < 5701 ) 
  134.   {
  135.     if ( n < 5317 ) 
  136.     printparam ( n - 5267 ) ; 
  137.     else if ( n < 5573 ) 
  138.     {
  139.       printesc ( 336 ) ; 
  140.       printint ( n - 5317 ) ; 
  141.     } 
  142.     else { 
  143.       printesc ( 337 ) ; 
  144.       printint ( n - 5573 ) ; 
  145.     } 
  146.     printchar ( 61 ) ; 
  147.     printint ( eqtb [ n ] .cint ) ; 
  148.   } 
  149.   else if ( n <= 5976 ) 
  150.   {
  151.     if ( n < 5721 ) 
  152.     printlengthp ( n - 5701 ) ; 
  153.     else { 
  154.       printesc ( 359 ) ; 
  155.       printint ( n - 5721 ) ; 
  156.     } 
  157.     printchar ( 61 ) ; 
  158.     printscaled ( eqtb [ n ] .cint ) ; 
  159.     print ( 262 ) ; 
  160.   } 
  161.   else printchar ( 63 ) ; 
  162. } 
  163. #endif /* STAT */
  164. halfword zidlookup ( j , l ) 
  165. integer j , l ; 
  166. {/* 40 */ register halfword Result; r_idlookup 
  167.   integer h ; 
  168.   halfword p ; 
  169.   halfword k ; 
  170.   h = buffer [ j ] ; 
  171.   for ( k = j + 1 ; k <= j + l - 1 ; k ++ ) 
  172.   {
  173.     h = h + h + buffer [ k ] ; 
  174.     while ( h >= 2551 ) h = h - 2551 ; 
  175.   } 
  176.   p = h + 258 ; 
  177.   while ( true ) { 
  178.     if ( hash [ p ] .v.RH > 0 ) 
  179.     if ( ( strstart [ hash [ p ] .v.RH + 1 ] - strstart [ hash [ p ] .v.RH ] ) 
  180.     == l ) 
  181.     if ( streqbuf ( hash [ p ] .v.RH , j ) ) 
  182.     goto lab40 ; 
  183.     if ( hash [ p ] .v.LH == 0 ) 
  184.     {
  185.       if ( nonewcontrol ) 
  186.       p = 3525 ; 
  187.       else { 
  188.     if ( hash [ p ] .v.RH > 0 ) 
  189.     {
  190.       do { if ( ( hashused == 258 ) ) 
  191.         overflow ( 362 , 3000 ) ; 
  192.         decr ( hashused ) ; 
  193.       } while ( ! ( hash [ hashused ] .v.RH == 0 ) ) ; 
  194.       hash [ p ] .v.LH = hashused ; 
  195.       p = hashused ; 
  196.     } 
  197.     {
  198.       if ( poolptr + l > poolsize ) 
  199.       overflow ( 128 , poolsize - initpoolptr ) ; 
  200.     } 
  201.     for ( k = j ; k <= j + l - 1 ; k ++ ) 
  202.     {
  203.       strpool [ poolptr ] = buffer [ k ] ; 
  204.       incr ( poolptr ) ; 
  205.     } 
  206.     hash [ p ] .v.RH = makestring () ; 
  207.  
  208. #ifdef STAT
  209.     incr ( cscount ) ; 
  210. #endif /* STAT */
  211.       } 
  212.       goto lab40 ; 
  213.     } 
  214.     p = hash [ p ] .v.LH ; 
  215.   } 
  216.   lab40: Result = p ; 
  217.   return(Result) ; 
  218. } 
  219.  
  220. #ifdef INITEX
  221. zprimitive ( s , c , o ) 
  222. strnumber s ; 
  223. quarterword c ; 
  224. halfword o ; 
  225. {r_primitive 
  226.   poolpointer k ; 
  227.   smallnumber j ; 
  228.   smallnumber l ; 
  229.   if ( s < 128 ) 
  230.   curval = s + 129 ; 
  231.   else { 
  232.     k = strstart [ s ] ; 
  233.     l = strstart [ s + 1 ] - k ; 
  234.     for ( j = 0 ; j <= l - 1 ; j ++ ) 
  235.     buffer [ j ] = strpool [ k + j ] ; 
  236.     curval = idlookup ( 0 , l ) ; 
  237.     {
  238.       decr ( strptr ) ; 
  239.       poolptr = strstart [ strptr ] ; 
  240.     } 
  241.     hash [ curval ] .v.RH = s ; 
  242.   } 
  243.   eqtb [ curval ] .hh.b1 = 1 ; 
  244.   eqtb [ curval ] .hh.b0 = c ; 
  245.   eqtb [ curval ] .hh .v.RH = o ; 
  246. } 
  247. #endif /* INITEX */
  248. znewsavelevel ( c ) 
  249. groupcode c ; 
  250. {r_newsavelevel 
  251.   if ( saveptr > maxsavestack ) 
  252.   {
  253.     maxsavestack = saveptr ; 
  254.     if ( maxsavestack > savesize - 6 ) 
  255.     overflow ( 399 , savesize ) ; 
  256.   } 
  257.   savestack [ saveptr ] .hh.b0 = 3 ; 
  258.   savestack [ saveptr ] .hh.b1 = curgroup ; 
  259.   savestack [ saveptr ] .hh .v.RH = curboundary ; 
  260.   if ( curlevel == 255 ) 
  261.   overflow ( 400 , 255 ) ; 
  262.   curboundary = saveptr ; 
  263.   incr ( curlevel ) ; 
  264.   incr ( saveptr ) ; 
  265.   curgroup = c ; 
  266. } 
  267. zeqdestroy ( w ) 
  268. memoryword w ; 
  269. {r_eqdestroy 
  270.   halfword q ; 
  271.   switch ( w .hh.b0 ) 
  272.   {case 110 : 
  273.   case 111 : 
  274.   case 112 : 
  275.   case 113 : 
  276.     deletetokenr ( w .hh .v.RH ) ; 
  277.     break ; 
  278.   case 116 : 
  279.     deletegluere ( w .hh .v.RH ) ; 
  280.     break ; 
  281.   case 117 : 
  282.     {
  283.       q = w .hh .v.RH ; 
  284.       if ( q != 0 ) 
  285.       freenode ( q , mem [(long) q ] .hh .v.LH + mem [(long) q ] .hh .v.LH + 1 ) ; 
  286.     } 
  287.     break ; 
  288.   case 118 : 
  289.     flushnodelis ( w .hh .v.RH ) ; 
  290.     break ; 
  291.   default : 
  292.     ; 
  293.     break ; 
  294.   } 
  295. } 
  296. zeqsave ( p , l ) 
  297. halfword p ; 
  298. quarterword l ; 
  299. {r_eqsave 
  300.   if ( saveptr > maxsavestack ) 
  301.   {
  302.     maxsavestack = saveptr ; 
  303.     if ( maxsavestack > savesize - 6 ) 
  304.     overflow ( 399 , savesize ) ; 
  305.   } 
  306.   if ( l == 0 ) 
  307.   savestack [ saveptr ] .hh.b0 = 1 ; 
  308.   else { 
  309.     savestack [ saveptr ] = eqtb [ p ] ; 
  310.     incr ( saveptr ) ; 
  311.     savestack [ saveptr ] .hh.b0 = 0 ; 
  312.   } 
  313.   savestack [ saveptr ] .hh.b1 = l ; 
  314.   savestack [ saveptr ] .hh .v.RH = p ; 
  315.   incr ( saveptr ) ; 
  316. } 
  317. zeqdefine ( p , t , e ) 
  318. halfword p ; 
  319. quarterword t ; 
  320. halfword e ; 
  321. {r_eqdefine 
  322.   if ( eqtb [ p ] .hh.b1 == curlevel ) 
  323.   eqdestroy ( eqtb [ p ] ) ; 
  324.   else if ( curlevel > 1 ) 
  325.   eqsave ( p , eqtb [ p ] .hh.b1 ) ; 
  326.   eqtb [ p ] .hh.b1 = curlevel ; 
  327.   eqtb [ p ] .hh.b0 = t ; 
  328.   eqtb [ p ] .hh .v.RH = e ; 
  329. } 
  330. zeqworddefine ( p , w ) 
  331. halfword p ; 
  332. integer w ; 
  333. {r_eqworddefine 
  334.   if ( xeqlevel [ p ] != curlevel ) 
  335.   {
  336.     eqsave ( p , xeqlevel [ p ] ) ; 
  337.     xeqlevel [ p ] = curlevel ; 
  338.   } 
  339.   eqtb [ p ] .cint = w ; 
  340. } 
  341. zgeqdefine ( p , t , e ) 
  342. halfword p ; 
  343. quarterword t ; 
  344. halfword e ; 
  345. {r_geqdefine 
  346.   eqdestroy ( eqtb [ p ] ) ; 
  347.   eqtb [ p ] .hh.b1 = 1 ; 
  348.   eqtb [ p ] .hh.b0 = t ; 
  349.   eqtb [ p ] .hh .v.RH = e ; 
  350. } 
  351. zgeqworddefin ( p , w ) 
  352. halfword p ; 
  353. integer w ; 
  354. {r_geqworddefin 
  355.   eqtb [ p ] .cint = w ; 
  356.   xeqlevel [ p ] = 1 ; 
  357. } 
  358. zsaveforafter ( t ) 
  359. halfword t ; 
  360. {r_sa